package com.qzh.G.constants;

import com.qzh.G.base.CalcType;
import com.qzh.G.base.EffType;
import com.qzh.G.base.Effect;
import com.qzh.G.base.TarType;

import java.math.BigDecimal;

public class Effects {
    public static Effect 生命增幅I;
    public static Effect 生命增幅II;
    public static Effect 生命增幅III;
    public static Effect 生命增幅IV;
    public static Effect 生命增幅V;
    public static Effect 攻击增幅I;
    public static Effect 攻击增幅II;
    public static Effect 攻击增幅III;
    public static Effect 攻击增幅IV;
    public static Effect 攻击增幅V;
    public static Effect 防御增幅I;
    public static Effect 防御增幅II;
    public static Effect 防御增幅III;
    public static Effect 防御增幅IV;
    public static Effect 防御增幅V;
    public static Effect 闪避增幅I;
    public static Effect 闪避增幅II;
    public static Effect 闪避增幅III;
    public static Effect 闪避增幅IV;
    public static Effect 闪避增幅V;
    public static Effect 暴击增幅I;
    public static Effect 暴击增幅II;
    public static Effect 暴击增幅III;
    public static Effect 暴击增幅IV;
    public static Effect 暴击增幅V;
    public static Effect 爆伤增幅I;
    public static Effect 爆伤增幅II;
    public static Effect 爆伤增幅III;
    public static Effect 爆伤增幅IV;
    public static Effect 爆伤增幅V;
////////////////////////////////////////////////////////////////////////////////////////
    public static Effect 低级恢复;

static {
    new Effects();}
    public Effects(){
        EffectFuwen();
        EffectItem();
    }
    public void EffectFuwen(){
        生命增幅I = new Effect();
        生命增幅I.setType(EffType.base);
        生命增幅I.setName("生命增幅I");
        生命增幅I.setDescription("提升20%基础生命值。");
        生命增幅I.setCalcType(CalcType.multi);
        生命增幅I.setValue(BigDecimal.valueOf(0.2));
        生命增幅I.setTarType(TarType.hpLimit);
        生命增幅II = new Effect();
        生命增幅II.setType(EffType.base);
        生命增幅II.setName("生命增幅II");
        生命增幅II.setDescription("提升40%基础生命值。");
        生命增幅II.setCalcType(CalcType.multi);
        生命增幅II.setValue(BigDecimal.valueOf(0.4));
        生命增幅II.setTarType(TarType.hpLimit);
        生命增幅III = new Effect();
        生命增幅III.setType(EffType.base);
        生命增幅III.setName("生命增幅III");
        生命增幅III.setDescription("提升60%基础生命值。");
        生命增幅III.setCalcType(CalcType.multi);
        生命增幅III.setValue(BigDecimal.valueOf(0.6));
        生命增幅III.setTarType(TarType.hpLimit);
        生命增幅IV = new Effect();
        生命增幅IV.setType(EffType.base);
        生命增幅IV.setName("生命增幅IV");
        生命增幅IV.setDescription("提升80%基础生命值。");
        生命增幅IV.setCalcType(CalcType.multi);
        生命增幅IV.setValue(BigDecimal.valueOf(0.8));
        生命增幅IV.setTarType(TarType.hpLimit);
        生命增幅V = new Effect();
        生命增幅V.setType(EffType.base);
        生命增幅V.setName("生命增幅V");
        生命增幅V.setDescription("提升100%基础生命值。");
        生命增幅V.setCalcType(CalcType.multi);
        生命增幅V.setValue(BigDecimal.valueOf(1.0));
        生命增幅V.setTarType(TarType.hpLimit);


       攻击增幅I = new Effect();
       攻击增幅I.setType(EffType.base);
       攻击增幅I.setName("攻击增幅I");
       攻击增幅I.setDescription("提升20%基础攻击力。");
       攻击增幅I.setCalcType(CalcType.multi);
       攻击增幅I.setValue(BigDecimal.valueOf(0.2));
       攻击增幅I.setTarType(TarType.attack);
       攻击增幅II = new Effect();
       攻击增幅II.setType(EffType.base);
       攻击增幅II.setName("攻击增幅II");
       攻击增幅II.setDescription("提升40%基础攻击力。");
       攻击增幅II.setCalcType(CalcType.multi);
       攻击增幅II.setValue(BigDecimal.valueOf(0.4));
       攻击增幅II.setTarType(TarType.attack);
       攻击增幅III = new Effect();
       攻击增幅III.setType(EffType.base);
       攻击增幅III.setName("攻击增幅III");
       攻击增幅III.setDescription("提升60%基础攻击力。");
       攻击增幅III.setCalcType(CalcType.multi);
       攻击增幅III.setValue(BigDecimal.valueOf(0.6));
       攻击增幅III.setTarType(TarType.attack);
       攻击增幅IV = new Effect();
       攻击增幅IV.setType(EffType.base);
       攻击增幅IV.setName("攻击增幅IV");
       攻击增幅IV.setDescription("提升80%基础攻击力。");
       攻击增幅IV.setCalcType(CalcType.multi);
       攻击增幅IV.setValue(BigDecimal.valueOf(0.8));
       攻击增幅IV.setTarType(TarType.attack);
       攻击增幅V = new Effect();
       攻击增幅V.setType(EffType.base);
       攻击增幅V.setName("攻击增幅V");
       攻击增幅V.setDescription("提升100%基础攻击力。");
       攻击增幅V.setCalcType(CalcType.multi);
       攻击增幅V.setValue(BigDecimal.valueOf(1.0));
       攻击增幅V.setTarType(TarType.attack);

        防御增幅I = new Effect();
        防御增幅I.setType(EffType.base);
        防御增幅I.setName("防御增幅I");
        防御增幅I.setDescription("提升20%基础防御力。");
        防御增幅I.setCalcType(CalcType.multi);
        防御增幅I.setValue(BigDecimal.valueOf(0.2));
        防御增幅I.setTarType(TarType.defend);
        防御增幅II = new Effect();
        防御增幅II.setType(EffType.base);
        防御增幅II.setName("防御增幅II");
        防御增幅II.setDescription("提升40%基础防御力。");
        防御增幅II.setCalcType(CalcType.multi);
        防御增幅II.setValue(BigDecimal.valueOf(0.4));
        防御增幅II.setTarType(TarType.defend);
        防御增幅III = new Effect();
        防御增幅III.setType(EffType.base);
        防御增幅III.setName("防御增幅III");
        防御增幅III.setDescription("提升60%基础防御力。");
        防御增幅III.setCalcType(CalcType.multi);
        防御增幅III.setValue(BigDecimal.valueOf(0.6));
        防御增幅III.setTarType(TarType.defend);
        防御增幅IV = new Effect();
        防御增幅IV.setType(EffType.base);
        防御增幅IV.setName("防御增幅IV");
        防御增幅IV.setDescription("提升80%基础防御力。");
        防御增幅IV.setCalcType(CalcType.multi);
        防御增幅IV.setValue(BigDecimal.valueOf(0.8));
        防御增幅IV.setTarType(TarType.defend);
        防御增幅V = new Effect();
        防御增幅V.setType(EffType.base);
        防御增幅V.setName("防御增幅V");
        防御增幅V.setDescription("提升100%基础防御力。");
        防御增幅V.setCalcType(CalcType.multi);
        防御增幅V.setValue(BigDecimal.valueOf(1.0));
        防御增幅V.setTarType(TarType.defend);


        闪避增幅I = new Effect();
        闪避增幅I.setType(EffType.base);
        闪避增幅I.setName("闪避增幅I");
        闪避增幅I.setDescription("提升20%基础闪避力。");
        闪避增幅I.setCalcType(CalcType.multi);
        闪避增幅I.setValue(BigDecimal.valueOf(0.2));
        闪避增幅I.setTarType(TarType.dodge_rate);
        闪避增幅II = new Effect();
        闪避增幅II.setType(EffType.base);
        闪避增幅II.setName("闪避增幅II");
        闪避增幅II.setDescription("提升40%基础闪避力。");
        闪避增幅II.setCalcType(CalcType.multi);
        闪避增幅II.setValue(BigDecimal.valueOf(0.4));
        闪避增幅II.setTarType(TarType.dodge_rate);
        闪避增幅III = new Effect();
        闪避增幅III.setType(EffType.base);
        闪避增幅III.setName("闪避增幅III");
        闪避增幅III.setDescription("提升60%基础闪避力。");
        闪避增幅III.setCalcType(CalcType.multi);
        闪避增幅III.setValue(BigDecimal.valueOf(0.6));
        闪避增幅III.setTarType(TarType.dodge_rate);
        闪避增幅IV = new Effect();
        闪避增幅IV.setType(EffType.base);
        闪避增幅IV.setName("闪避增幅IV");
        闪避增幅IV.setDescription("提升80%基础闪避力。");
        闪避增幅IV.setCalcType(CalcType.multi);
        闪避增幅IV.setValue(BigDecimal.valueOf(0.8));
        闪避增幅IV.setTarType(TarType.dodge_rate);
        闪避增幅V = new Effect();
        闪避增幅V.setType(EffType.base);
        闪避增幅V.setName("闪避增幅V");
        闪避增幅V.setDescription("提升100%基础闪避力。");
        闪避增幅V.setCalcType(CalcType.multi);
        闪避增幅V.setValue(BigDecimal.valueOf(1.0));
        闪避增幅V.setTarType(TarType.dodge_rate);


        暴击增幅I = new Effect();
        暴击增幅I.setType(EffType.base);
        暴击增幅I.setName("暴击增幅I");
        暴击增幅I.setDescription("提升20%基础暴击力。");
        暴击增幅I.setCalcType(CalcType.multi);
        暴击增幅I.setValue(BigDecimal.valueOf(0.2));
        暴击增幅I.setTarType(TarType.chr);
        暴击增幅II = new Effect();
        暴击增幅II.setType(EffType.base);
        暴击增幅II.setName("暴击增幅II");
        暴击增幅II.setDescription("提升40%基础暴击力。");
        暴击增幅II.setCalcType(CalcType.multi);
        暴击增幅II.setValue(BigDecimal.valueOf(0.4));
        暴击增幅II.setTarType(TarType.chr);
        暴击增幅III = new Effect();
        暴击增幅III.setType(EffType.base);
        暴击增幅III.setName("暴击增幅III");
        暴击增幅III.setDescription("提升60%基础暴击力。");
        暴击增幅III.setCalcType(CalcType.multi);
        暴击增幅III.setValue(BigDecimal.valueOf(0.6));
        暴击增幅III.setTarType(TarType.chr);
        暴击增幅IV = new Effect();
        暴击增幅IV.setType(EffType.base);
        暴击增幅IV.setName("暴击增幅IV");
        暴击增幅IV.setDescription("提升80%基础暴击力。");
        暴击增幅IV.setCalcType(CalcType.multi);
        暴击增幅IV.setValue(BigDecimal.valueOf(0.8));
        暴击增幅IV.setTarType(TarType.chr);
        暴击增幅V = new Effect();
        暴击增幅V.setType(EffType.base);
        暴击增幅V.setName("暴击增幅V");
        暴击增幅V.setDescription("提升100%基础暴击力。");
        暴击增幅V.setCalcType(CalcType.multi);
        暴击增幅V.setValue(BigDecimal.valueOf(1.0));
        暴击增幅V.setTarType(TarType.chr);

        爆伤增幅I = new Effect();
        爆伤增幅I.setType(EffType.base);
        爆伤增幅I.setName("爆伤增幅I");
        爆伤增幅I.setDescription("提升20%基础爆伤力。");
        爆伤增幅I.setCalcType(CalcType.multi);
        爆伤增幅I.setValue(BigDecimal.valueOf(0.2));
        爆伤增幅I.setTarType(TarType.chd);
        爆伤增幅II = new Effect();
        爆伤增幅II.setType(EffType.base);
        爆伤增幅II.setName("爆伤增幅II");
        爆伤增幅II.setDescription("提升40%基础爆伤力。");
        爆伤增幅II.setCalcType(CalcType.multi);
        爆伤增幅II.setValue(BigDecimal.valueOf(0.4));
        爆伤增幅II.setTarType(TarType.chd);
        爆伤增幅III = new Effect();
        爆伤增幅III.setType(EffType.base);
        爆伤增幅III.setName("爆伤增幅III");
        爆伤增幅III.setDescription("提升60%基础爆伤力。");
        爆伤增幅III.setCalcType(CalcType.multi);
        爆伤增幅III.setValue(BigDecimal.valueOf(0.6));
        爆伤增幅III.setTarType(TarType.chd);
        爆伤增幅IV = new Effect();
        爆伤增幅IV.setType(EffType.base);
        爆伤增幅IV.setName("爆伤增幅IV");
        爆伤增幅IV.setDescription("提升80%基础爆伤力。");
        爆伤增幅IV.setCalcType(CalcType.multi);
        爆伤增幅IV.setValue(BigDecimal.valueOf(0.8));
        爆伤增幅IV.setTarType(TarType.chd);
        爆伤增幅V = new Effect();
        爆伤增幅V.setType(EffType.base);
        爆伤增幅V.setName("爆伤增幅V");
        爆伤增幅V.setDescription("提升100%基础爆伤力。");
        爆伤增幅V.setCalcType(CalcType.multi);
        爆伤增幅V.setValue(BigDecimal.valueOf(1.0));
        爆伤增幅V.setTarType(TarType.chd);

















    }
    public void EffectItem(){
        低级恢复 =new Effect();
        低级恢复.setName("低级恢复");
        低级恢复.setValue(BigDecimal.valueOf(50));
        低级恢复.setType(EffType.present);
        低级恢复.setCalcType(CalcType.add);
        低级恢复.setTarType(TarType.hp);
        低级恢复.setDescription("低品阶的恢复效果");
    }
}
